package com.colabo.j2ee.web.core.dao.mediator;

import java.io.Serializable;
import java.sql.Connection;
import java.util.List;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.orm.ibatis.SqlMapClientTemplate;

import com.colabo.j2ee.web.core.dao.mediator.impl.DefaultMediatorImpl;
import com.colabo.j2ee.web.core.exception.MediatorException;
import com.colabo.j2ee.web.core.vo.RecordObject;

/**
 * 持久层操作的接口 完成增删、条件查询、批量更新等操作,
 * 以及面对高级操作的支持如获取java.sql.Connection,HibernateTemplate,SqlMapClientTempalte等
 */
public interface IDefaultMediator {
	/**
	 * 提供获取数据库连接的接口，以便更高灵活性的操作需求 该Connection将从注入的DataSource中获取
	 * 
	 * @return SQL Connection
	 * @throws MediatorException
	 */
	public Connection getConnection() throws MediatorException;

	/**
	 * 插入数据，采用Hibernate的对象操作方式完成<br>
	 * 使用方法：<br>
	 * 
	 * <pre>
	 * AccountVO accountVO = new AccountVO();
	 * <br>
	 * accountVO.setKy(123456l);
	 * <br>
	 * accountVO.setAccountNO(&quot;123&quot;);
	 * <br>
	 * defautMediator.save_Hibernate_Object(account);
	 * <br>
	 * </pre>
	 * 
	 * @param vo
	 *            要插入的数据对象，必须是从ValueObject继承过来的
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public int save_Hibernate_Object(RecordObject vo) throws MediatorException;

	/**
	 * 插入数据，采用iBatis完成<br>
	 * 
	 * 使用方法：<br>
	 * 
	 * <pre>
	 * 		1:假设iBatis配置文件中的操作语句为：
	 * <br>
	 * 		&lt;sqlMap namespace=&quot;Account&quot;&gt;		
	 * <br>
	 * 			......
	 * <br>
	 * 			&lt;insert id=&quot;insertAccount&quot; parameterMap=&quot;insertParam&quot;&gt;
	 * <br>
	 * 			insert into ACCOUNT ( accountky, accountno,CREATEDTIME) values ( ?,?,?)
	 * <br>
	 * 		&lt;/insert&gt;
	 * <br>
	 * 		......
	 * <br>
	 * 	&lt;/sqlMap &gt;
	 * <br>
	 * 则可见参数params将以parameterMap的形式传递
	 * <br>
	 * 		2：调用save_iBatis方法
	 * <br>
	 * String sqlmap_name = &quot;Account.insertAccount&quot;;
	 * <br>
	 * AccountVO accountVO = new AccountVO();
	 * <br>
	 * 		......
	 * <br>
	 * defautMediator.save_iBatis(sqlmap_name, new Object[] { accountVO });
	 * <br>
	 * </pre>
	 * 
	 * @param queryID
	 *            在iBatis映射文件中配置的sql语句编号<br>
	 * @param params
	 *            参数列表，可为null
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public int save_iBatis(final String queryID, final Object[] params) throws MediatorException;

	/**
	 * 插入数据，采用JDBC完成<br>
	 * 使用方法<br>
	 * 
	 * <pre>
	 * String jdbc_query = &quot;insert into account(accountky,accountno,createdtime) values(555555,'123','&quot; + 某个变量值 + &quot;')&quot;;
	 * <br>
	 * defautMediator.save_JDBC(jdbc_query, null);
	 * <br>
	 * </pre>
	 * 
	 * @param sql
	 *            纯粹的sql格式的Insert语句
	 * @param params
	 *            参数列表，如下两种情况下可以为null<br>
	 *            <p/>1：传入的SQL语句一般已经完成了拼装<br>
	 *            <p/>2：传入的SQL语句没有参数<br>
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public int save_JDBC(final String sql, final Object[] params) throws MediatorException;

	/**
	 * 插入数据，采用Hibernate的自定义sql语句方式完成<br>
	 * 借助HibernateTemplae的回调机制实现，使用createSQLQuery方法<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * String hibernate_sql = &quot;insert into account(accountky,accountno,createdtime) values(?,?,?)&quot;;
	 * <br>
	 * defautMediator.save_Hibernate_ComposedQuery(hibernate_sql, new Object[] { 123, &quot;123&quot;, strdate });
	 * <br>
	 * </pre>
	 * 
	 * @param composedSQL
	 *            写在代码中的sql语句,非hql格式
	 * @param params
	 *            参数列表，可为null
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public int save_Hibernate_ComposedQuery(final String composedSQL, final Object[] params) throws MediatorException;

	/**
	 * 删除操作，采用Hibernate的对象操作方式完成<br>
	 * 调用Hibernate的delete方法实现<br>
	 * 
	 * 使用方法
	 * 
	 * <pre>
	 * AccountVO accountVO = new AccountVO();
	 * <br>
	 * 		......
	 * <br>
	 * defautMediator.delete_Hibernate_Object(accountVO);
	 * <br>
	 * </pre>
	 * 
	 * @param vo
	 *            要删除的数据对象，必须是从ValueObject继承过来的
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public int delete_Hibernate_Object(RecordObject vo) throws MediatorException;

	/**
	 * 根据主键进行的删除操作，采用Hibernate的对象操作方式完成<br>
	 * 将先根据findByID_Hibernate_Get方法获取对象，再调用Hibernate的delete方法<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * AccountVO accountVO = new AccountVO();
	 * <br>
	 * defautMediator.deleteByID_Hibernate_Object(account.getClass(), Long.valueOf(&quot;555555&quot;));
	 * <br>
	 * </pre>
	 * 
	 * @param cls
	 *            要删除的对象类型，该对象类型必须是继承自ValueObject
	 * @param id
	 *            主键
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public int deleteByID_Hibernate_Object(Class<?> cls, Serializable id) throws MediatorException;

	/**
	 * 删除操作，采用JDBC完成<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * String jdcb_delete_sql = &quot;delete from account where accountky=555555&quot;;
	 * <br>
	 * defautMediator.delete_JDBC(jdcb_delete_sql, null);
	 * <br>
	 * </pre>
	 * 
	 * @param sql
	 *            纯粹的sql格式delete语句
	 * @param params
	 *            参数列表，如下两种情况下可以为null<br>
	 *            <p/>1：传入的SQL语句一般已经完成了拼装<br>
	 *            <p/>2：传入的SQL语句没有参数<br>
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public int delete_JDBC(final String sql, final Object[] params) throws MediatorException;

	/**
	 * 删除操作，采用iBatis完成<br>
	 * <br>
	 * 使用方法1<br>
	 * 
	 * <pre>
	 * 		1:iBatis的配置文件：
	 * <br>
	 * 			&lt;delete id=&quot;deleteAccountById&quot; parameterClass=&quot;Long&quot;&gt;
	 * <br>
	 *   			delete from ACCOUNT where accountky = #objectId#
	 * <br>
	 * 		&lt;/delete&gt;
	 * <br>
	 * 	可见其中的参数是以java基本数据对象的parameterClass形式进行传递的，保存在数值的Index=0的位置
	 * <br>
	 * 		2：调用
	 * <br>
	 * String ibatis_delete = &quot;Account.deleteAccountById&quot;;
	 * <br>
	 * defautMediator.delete_iBatis(ibatis_delete, new Object[] { 555555L });
	 * <br>
	 * </pre>
	 * 
	 * 使用方法2<br>
	 * 
	 * <pre>
	 * 		1:iBatis的配置文件：
	 * <br>
	 * 			&lt;delete id=&quot;deleteAccountByParamClass&quot; parameterClass=&quot;Account&quot;&gt;
	 * <br>
	 * 			delete from ACCOUNT where accountky = #objectId# and accountno= #accountNo#
	 * <br>
	 * 		&lt;/delete&gt;
	 * <br>
	 * 	可见其中的参数是以自定义Account的parameterClass形式进行传递的，保存在数值的Index=0的位置
	 * <br>
	 * 		2：调用
	 * <br>
	 * String ibatis_delete = &quot;Account.deleteAccountByParamClass&quot;;
	 * <br>
	 * AccountVO accountVO = new AccountVO();
	 * <br>
	 * 		......
	 * <br>
	 * defautMediator.delete_iBatis(ibatis_delete, new Object[] { accountVO });
	 * <br>
	 * </pre>
	 * 
	 * @param queryID
	 *            在iBatis映射文件中配置的sql语句编号
	 * @param params
	 *            参数列表,可为null
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public int delete_iBatis(final String queryID, final Object[] params) throws MediatorException;

	/**
	 * 删除操作，采用Hibernate的命名查询语句方式完成<br>
	 * 借助HibernateTemplae的回调机制实现，使用createQuery方法<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * 		1:Hibernate的配置文件中
	 * <br>
	 * 			&lt;sql-query	name=&quot;com.cib.app.account.vo.AccountVO.deleteSql&quot;&gt;
	 * <br>
	 * 			delete AccountVO where accountNo=? and accountky=?
	 * <br>
	 * 		&lt;/sql-query&gt;
	 * <br>
	 * 		2：调用方法
	 * <br>
	 * String hibernate_delete_namedquery_hql = &quot;com.cib.app.account.vo.AccountVO.deleteSql&quot;;
	 * <br>
	 * defautMediator.delete_Hibernate_NamedQuery(hibernate_delete_namedquery_hql, new Object[] { &quot;555&quot;, 555555 });
	 * <br>
	 * </pre>
	 * 
	 * @param queryID
	 *            在Hibernate映射文件中配置的查询语句编号,该语句是hql格式
	 * @param params
	 *            参数列表,可为null
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public int delete_Hibernate_NamedQuery(final String queryID, final Object[] params) throws MediatorException;

	/**
	 * 删除操作，采用Hibernate的自定义sql语句方式完成<br>
	 * 借助HibernateTemplae的回调机制实现，使用createSQLQuery<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * String hibernate_delete_sql = &quot;delete account where accountky=? and accountno=?&quot;;
	 * <br>
	 * defautMediator.delete_Hibernate_ComposedQuery(hibernate_delete_sql, new Object[] { 555555, &quot;5555&quot; });
	 * <br>
	 * </pre>
	 * 
	 * @param composedSQL
	 *            写在代码中的sql语句,非hql格式
	 * @param params
	 *            参数列表，可为null
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public int delete_Hibernate_ComposedQuery(final String composedSQL, final Object[] params) throws MediatorException;

	/**
	 * 更新操作，采用Hibernate的对象操作方式完成<br>
	 * 调用Hibernate的save方法实现<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * AccountVO accountVO = new AccountVO();
	 * <br>
	 * accountVO.setAccoutNO(xxx);
	 * <br>
	 * 		......
	 * <br>
	 * defautMediator.update_Hibernate_Object(account);
	 * <br>		
	 * </pre>
	 * 
	 * @param vo
	 *            要更新的数据对象，必须是从ValueObject继承过来的
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public int update_Hibernate_Object(RecordObject vo) throws MediatorException;

	/**
	 * 更新操作，采用JDBC完成<br>
	 * 
	 * 使用方法
	 * 
	 * <pre>
	 * String jdbc_update_sql = &quot;update ACCOUNT set accountno =090 where accountky =555555&quot;;
	 * <br>
	 * defautMediator.update_JDBC(jdbc_update_sql, null);
	 * <br>
	 * </pre>
	 * 
	 * @param sql
	 *            纯粹的sql格式的update语句<br>
	 * @param params
	 *            参数列表，鉴于如下两种情况，用jdbc的query是个完整的sql语句，params不起作用，可以为null<br>
	 *            <p/>1：传入的SQL语句一般已经完成了拼装<br>
	 *            <p/>2：传入的SQL语句没有参数<br>
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public int update_JDBC(final String sql, final Object[] params) throws MediatorException;

	/**
	 * 更新操作，采用iBatis完成<br>
	 * 调用iBatis的update方法实现<br>
	 * 
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * 		1:iBatis配置文件中
	 * 		&lt;update id=&quot;updateAccount&quot; parameterClass=&quot;Account&quot;&gt;
	 * <br>
	 * 		update ACCOUNT set accountno = #accountNo# where accountky =#objectId#
	 * <br>
	 * 	&lt;/update&gt;
	 * <br>
	 * 可见参数是以自定义的Account的parameterClass形式进行传递的
	 * <br>
	 * 		2：调用方法：
	 * <br>
	 * String ibaits_update_query = &quot;Account.updateAccount&quot;;
	 * <br>
	 * defautMediator.update_iBatis(ibaits_update_query, new Object[] { account });
	 * <br>
	 * </pre>
	 * 
	 * @param queryID
	 *            在iBatis映射文件中配置的sql语句编号<br>
	 * @param params
	 *            参数列表,可为null
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public int update_iBatis(final String queryID, final Object[] params) throws MediatorException;

	/**
	 * 更新操作，采用Hibernate的命名查询语句方式完成<br>
	 * 借助HibernateTemplae的回调机制实现，使用createQuery方法，因此queryID对应的语句是hql语句<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * 		1:Hibernate的配置文件
	 * <br>
	 * 			&lt;sql-query	name=&quot;com.cib.app.account.vo.AccountVO.excuteSql&quot;&gt;
	 * <br>
	 * 			update AccountVO set accountNo=? where accountky=?
	 * <br>
	 * 			&lt;/sql-query&gt;
	 * <br>
	 * 		2：调用方法
	 * <br>
	 * String hibernate_namedquery = &quot;com.cib.app.account.vo.AccountVO.excuteSql&quot;;
	 * <br>
	 * defautMediator.update_Hibernate_NamedQuery(hibernate_namedquery, new Object[] { &quot;222&quot;, 555555 });
	 * <br>
	 * </pre>
	 * 
	 * @param queryID
	 *            在Hibernate映射文件中配置的查询语句编号,该语句是hql格式
	 * @param params
	 *            参数列表,可为null<br>
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public int update_Hibernate_NamedQuery(final String queryID, final Object[] params) throws MediatorException;

	/**
	 * 更新操作，采用Hibernate的自定义sql语句方式完成<br>
	 * 借助HibernateTemplae的回调机制实现，使用createSQLQuery方法，因此composedSQL对应的语句是sql语句<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * String hibernate_sql = &quot;update ACCOUNT set accountno =? where accountky =?&quot;;
	 * <br>
	 * defautMediator.update_Hibernate_ComposedQuery(hibernate_sql, new Object[] { &quot;83838383&quot;, 555555 });
	 * <br>
	 * </pre>
	 * 
	 * @param composedSQL
	 *            写在代码中的sql语句,非hql格式<br>
	 * @param params
	 *            参数列表,可为null
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public int update_Hibernate_ComposedQuery(final String composedSQL, final Object[] params) throws MediatorException;

	/**
	 * 根据主键查找对象，采用Hibernate的load方法实现<br>
	 * 如果该对象不存在，将抛出异常<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * 		AccountVO vo=(AccountVO)defautMediator.findByID_Hibernate_Load  (AccountVO.class(), Long.valueOf(555555)) ;	
	 * <br>		
	 * </pre>
	 * 
	 * @param cls
	 *            要删除的对象类型，该对象类型必须是继承自ValueObject<br>
	 * @param id
	 *            主键
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public RecordObject findByID_Hibernate_Load(Class<?> cls, Serializable id) throws MediatorException;

	/**
	 * 根据主键查找对象，采用Hibernate的get方法实现<br>
	 * 如果该对象不存在，将返回null<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * 		AccountVO vo=(AccountVO)defautMediator.findByID_Hibernate_Get (AccountVO.class(), Long.valueOf(555555)) ;	
	 * <br>		 		
	 * </pre>
	 * 
	 * @param cls
	 *            要删除的对象类型，该对象类型必须是继承自ValueObject<br>
	 * @param id
	 *            主键<br>
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public RecordObject findByID_Hibernate_Get(Class<?> cls, Serializable id) throws MediatorException;

	/**
	 * 根据主键查找对象，采用Hibernate的命名查询方法实现<br>
	 * 调用Hibernate的findByNamedQuery方法实现,<br>
	 * 预定义的语句中，必须有return alias，否则无法确保对象取出<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * 		1:Hibernate配置文件中
	 * <br>
	 * 		&lt;sql-query  name=&quot;com.cib.app.account.vo.AccountVO.querySql&quot;&gt;
	 * <br>
	 * 		&lt;return alias=&quot;account&quot; class=&quot;com.cib.app.account.vo.AccountVO&quot; /&gt;
	 * <br>
	 * 			select accountky,accountNo,createdtime FROM account WHERE  accountky=?
	 * <br>
	 * 	&lt;/sql-query&gt;
	 * <br>
	 * 		2:调用方法
	 * <br>
	 * String hibernate_findid_namedquery = &quot;com.cib.app.account.vo.AccountVO.querySql&quot;;
	 * <br>
	 * AccountVO vo = (AccountVO) defautMediator.findByID_Hibernate_NamedQuery(hibernate_findid_namedquery, Long
	 * 		.valueOf(555555));
	 * <br>
	 * </pre>
	 * 
	 * @param queryID
	 *            在Hibernate映射文件中配置的查询语句编号,该语句是sql格式对表进行操作<br>
	 * @param id
	 *            主键
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public RecordObject findByID_Hibernate_NamedQuery(String queryID, Serializable id) throws MediatorException;

	/**
	 * 根据主键查找对象，采用Hibernate的自定义hql语句方式完成<br>
	 * 调用Hibernate的find方法实现，该方法原本返回List，本方法中将从逻辑上取第一个值<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * String hibernate_findid_hql = &quot;select new com.cib.app.account.vo.AccountVO(objectId,accountNo) from AccountVO where objectId=?&quot;;
	 * <br>
	 * AccountVO vo = (AccountVO) defautMediator.findByID_Hibernate_ComposedHQL(hibernate_findid_hql, Long.valueOf(555555));
	 * <br>
	 * 		在本例中，返回值可以是自定义的一个对象，该对象可以是Hibernate环境中的一个Bean，也可以是一个普通的pojo
	 * <br>
	 * </pre>
	 * 
	 * @param composedHQL
	 *            <br>
	 *            写在代码中的hql语句,非sql格式，由于返回值为ValueObject的派生类，因此需要使用hql的方式约束返回值的类型<br>
	 * @param id
	 *            主键
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public RecordObject findByID_Hibernate_ComposedHQL(String composedHQL, Serializable id) throws MediatorException;

	/**
	 * 根据主键查找对象，采用iBatis方式完成<br>
	 * 调用iBatis的queryForObject方法实现<br>
	 * 
	 * 使用方法1<br>
	 * iBatis的resultClass机制，在本例中，返回列的名称必须在resultClass中域的范围内<br>
	 * 
	 * <pre>
	 * 		1：iBatis配置文件中
	 * <br>
	 *  	&lt;select id=&quot;selectAccountById&quot; parameterClass=&quot;Long&quot; resultClass=&quot;Account&quot;&gt;
	 * <br>
	 * 		select accountky as objectid, accountno as accountno from ACCOUNT where accountky = #objectId#
	 * <br>
	 * 	&lt;/select&gt;
	 * <br>
	 * 		2：调用方法
	 * <br>
	 * String ibatis_findid_query = &quot;Account.selectAccountById&quot;;
	 * <br>
	 * AccountVO vo = (AccountVO) defautMediator.findByID_iBatis(ibatis_findid_query, Long.valueOf(555555));
	 * <br>
	 * </pre>
	 * 
	 * 使用方法2<br>
	 * iBatis的resultMap机制，在本例中，返回列的名称通过resultMap进行转换，以此和Class域匹配<br>
	 * 
	 * <pre>
	 * 		1:iBatis的配置文件中
	 * <br>
	 * 			&lt;resultMap id=&quot;AccountResult&quot; class=&quot;Account&quot;&gt;
	 * <br>
	 * 			&lt;result property=&quot;objectId&quot; column=&quot;accountky&quot; /&gt;
	 * <br>
	 * 			&lt;result property=&quot;accountNo&quot; column=&quot;accountNo&quot; /&gt;
	 * <br>
	 * 			&lt;result property=&quot;createdTime&quot; column=&quot;CREATEDTIME&quot; /&gt;
	 * <br>
	 * 		&lt;/resultMap&gt;
	 * <br>
	 * 		......
	 * <br>
	 * 		&lt;select id=&quot;selectAccountWithMap&quot; parameterClass=&quot;Long&quot;  resultMap=&quot;AccountResult&quot;&gt;
	 * <br>
	 * 			select accountky  , accountno ,createdtime  from  ACCOUNT where accountky != #objectId#
	 * <br>
	 * 		&lt;/select&gt;
	 * <br>
	 * 		2:调用方法
	 * <br>
	 * String ibatis_findid_query2 = &quot;Account.selectAccountByIdWithMap&quot;;
	 * <br>
	 * AccountVO vo = (AccountVO) defautMediator.findByID_iBatis(ibatis_findid_query2, Long.valueOf(555555));
	 * <br>
	 * </pre>
	 * 
	 * @param queryID
	 *            在iBatis映射文件中配置的sql语句编号
	 * @param id
	 *            主键
	 * @return 操作所影响的记录数
	 * @throws MediatorException
	 */
	public RecordObject findByID_iBatis(String queryID, Serializable id) throws MediatorException;

	/**
	 * 查询，采用Hibernate的对象操作方法完成<br>
	 * 调用Hibernate的LoadALL方法完成<br>
	 * 使用方法
	 * 
	 * <pre>
	 * List list = defautMediator.findAll_Hibernate_Object(AccountVO.class);
	 * <br>	
	 *</pre>
	 * 
	 * @param cls
	 *            <br>
	 *            要查找的对象类型，该对象类型必须是继承自ValueObject<br>
	 * @return 查询到的所有结果列表，每个Item中就是cls
	 * @throws MediatorException
	 */
	public List<RecordObject> findAll_Hibernate_Object(Class<?> cls) throws MediatorException;

	/**
	 * 查询，采用JDBC完成<br>
	 * 调用HibernateTemplae的queryForList方法<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * String jdbc_findall_sql = &quot;select * from account&quot;;
	 * <br>
	 * List list = defautMediator.findAll_JDBC(jdbc_findall_sql);
	 * <br>
	 * 	注意：List返回结果中的Item是Map类型，account表中的每个字段作为该Map的key
	 * <br>
	 *</pre>
	 * 
	 * @param sql
	 *            纯粹的sql格式的select语句
	 * @return 查询到的所有结果列表，列表是由Map组成的List，Map中每个key就是返回值中的列名<br>
	 *         <p/>如sql="SELECT NAME,SEX,AGE FROM<br>
	 *         EMPLOYEE",则每个item就是Map，而map.get(NAME)就能却道取到name对应的值<br>
	 * @throws MediatorException
	 */
	public List<?> findAll_JDBC(String sql) throws MediatorException;

	/**
	 * 查询，采用iBatis完成<br>
	 * 用iBatis的queryForList完成，需要在映射文件中的查询语句中有ResultClass或者ResultMap，这样能够使返回列表中是由对象组成的<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * 		1:iBatis的配置文件
	 * <br>
	 * 		&lt;select id=&quot;selectAllAccounts&quot; resultMap=&quot;AccountResult&quot; &gt;
	 * <br>
	 * 		select * from ACCOUNT
	 * <br>
	 * 	&lt;/select&gt;
	 * <br>
	 * 		2：调用方法
	 * <br>
	 * String ibatis_findall_query = &quot;Account.selectAllAccounts&quot;;
	 * <br>
	 * List list = defautMediator.findAll_iBatis(ibatis_findall_query);
	 * <br>
	 * </pre>
	 * 
	 * @param queryID
	 *            在iBatis映射文件中配置的sql语句编号<br>
	 * @return 查询到的所有结果列表
	 * @throws MediatorException
	 */
	public List<?> findAll_iBatis(String queryID) throws MediatorException;

	/**
	 * 查询，采用Hibernate的自定义hql语句方式完成<br>
	 * 用Hibernate的find接口完成，自定义hql语句操作，<br>
	 * <p/>1:如select a , b from AVO ,返回的List中是对象数组Object[]组成的<br>
	 * <p/>2:如select new BVO(a , b ) from AVO ,返回的List中是BVO对象组成的，当然BVO和AVO可以是同一个<br>
	 * 
	 * 使用方法1<br>
	 * 
	 * <pre>
	 * String hibernate_findall_sql = &quot;select objectId,accountNo,createdTime from AccountVO&quot;;
	 * <br>
	 * List list = defautMediator.findAll_Hibernate_ComposedHQL(hibernate_findall_sql);
	 * <br>
	 * 		注意：返回List列表中，Item是Object[],可通过Index获得值
	 * <br>
	 * </pre>
	 * 
	 * 使用方法2
	 * 
	 * <pre>
	 * String hibernate_findall_sql2 = &quot;select new com.cib.app.account.vo.AccountVO(objectId,accountNo,createdTime) from AccountVO&quot;;
	 * <br>
	 * List list = defautMediator.findAll_Hibernate_ComposedHQL(hibernate_findall_sql2);
	 * <br>
	 * 		注意：返回值列表List中的Item是AccountVO
	 * <br>
	 * </pre>
	 * 
	 * @param composedHQL
	 *            写在代码中的hql语句,非sql格式
	 * @return 查询到的所有结果列表,<br>
	 *         <p/>1：List中是对象数组Object[]组成的<br>
	 *         <p/>2：List中是VO的派生类组成的<br>
	 * @throws MediatorException
	 */
	public List<?> findAll_Hibernate_ComposedHQL(String composedHQL) throws MediatorException;

	/**
	 * 查询，采用Hibernate的命名查询语句方式完成<br>
	 * 预定义的语句中，必须有return alias，否则无法确保对象取出<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * 		1:Hibernate的配置文件中
	 * <br>
	 * 		&lt;sql-query name=&quot;com.cib.app.account.vo.AccountVO.queryAll&quot;&gt;
	 * <br>
	 * 		&lt;return alias=&quot;account&quot; class=&quot;com.cib.app.account.vo.AccountVO&quot; /&gt;
	 * <br>
	 * 			select accountky,accountNo,createdtime FROM account
	 * <br>
	 *  
	 * 	&lt;/sql-query&gt;
	 * <br>
	 * 		2:调用方法
	 * <br>
	 * String hibernate_findall_namedquery = &quot;com.cib.app.account.vo.AccountVO.queryAll&quot;;
	 * <br>
	 * List list = defautMediator.findAll_Hibernate_NamedQuery(hibernate_findall_namedquery);
	 * <br>
	 * </pre>
	 * 
	 * @param queryID
	 *            <br>
	 *            在Hibernate映射文件中配置的查询语句编号,该语句是sql格式<br>
	 * @return return alias组成的List
	 * @throws MediatorException
	 */
	public List<?> findAll_Hibernate_NamedQuery(String queryID) throws MediatorException;

	/**
	 * 使用iBatis完成复杂的查询操作，支持分页<br>
	 * 关于iBatis分页机制的说明<br>
	 * <p/> 1：数据库支持物理分页的，如MySQL,Oracle,SQL Server2005等，交给数据库本身处理<p/>
	 * 2：数据库不支持物理分页的，如informix,Sybase
	 * 12.5.3,SQLServer，交给JDBC驱动的ResultSet的absolute定位完成<p/>
	 * 3：以上都不支持的，通过ResultSet.next()方式逐条遍历<p/>
	 * 
	 * <p/> 关于如何使用iBatis分页机制的操作说明<br>
	 * 1：是否要用平台优化的分页功能，目前在实现类<code>DefaultMediatorImpl</code>中是规定必须要的，因此在本方法的实现中强制了setEnableCustomizedPaged(true);
	 * {@link DefaultMediatorImpl#setEnableCustomizedPaged(boolean) DefaultMediatorImpl.setEnableCustomizedPaged}
	 * 2：在Spring的配置文件中，对于IMediator的实现类的配置如下 &lt;bean id="defaultMediator"
	 * class="com.cib.cap.base.dao.mediator.impl.DefaultMediatorImpl"
	 * <br>
	 * init-method="initialize" &gt; <br>
	 * &lt;!--以下配置Hibernate的连接session--&gt;<br>
	 * &lt;property name="sessionFactory"&gt;<br>
	 * &lt;ref bean="sessionFactory"/&gt;<br>
	 * &lt;/property&gt;<br>
	 * &lt;!--以下配置iBatis的连接session--&gt;<br>
	 * &lt;property name="sqlMapClient"&gt;<br>
	 * &lt;ref bean="sqlMapClient"/&gt;<br>
	 * &lt;/property&gt;<br>
	 * &lt;!--以下配置jdbc的连接datasource--&gt;<br>
	 * &lt;property name="dataSource"&gt;<br>
	 * &lt;ref bean="dataSource"/&gt;<br>
	 * &lt;/property&gt;<br>
	 * &lt;!--以下配置iBatis的分页扩展机制--&gt;<br>
	 * &lt;property name="sqlExecutor"&gt;<br>
	 * &lt;ref bean="sqlExecutor"/&gt;<br>
	 * &lt;/property&gt;<br>
	 * &lt;/bean&gt;<br>
	 * 3：在persistence/ibatis.xml文件中，需要配置好各种数据库对应的分页机制实现类，同时在sqlExecutor中选择当前使用的数据库分页类
	 * &lt;bean id="sqlExecutor"
	 * class="com.cib.cap.base.dao.orm.IBatisSqlExecutor"&gt;
	 * <br>
	 * &lt;property name="dialect"&gt; <br>
	 * &lt;ref bean="oracleDialect" /&gt; <br>
	 * &lt;/property&gt; <br>
	 * &lt;/bean&gt; <br>
	 * <bean id="oracleDialect"
	 * class="com.cib.cap.base.dao.orm.impl.OracleDialect"/>
	 * <br>
	 * <bean id="db2Dialect"
	 * class="com.cib.cap.base.dao.orm.impl.DB2Dialect"/> <br>
	 * <bean id="mssqlDialect"
	 * class="com.cib.cap.base.dao.orm.impl.SQLServerDialect"/>
	 * <br>
	 * <bean id="mssq2005lDialect"
	 * class="com.cib.cap.base.dao.orm.impl.SQLServer2005Dialect"/>
	 * <br>
	 * <bean id="sybaseDialect"
	 * class="com.cib.cap.base.dao.orm.impl.SybaseDialect"/>
	 * <br>
	 * <bean id="informixDialect"
	 * class="com.cib.cap.base.dao.orm.impl.InformixDialect"/>
	 * <br>
	 * 
	 * </p>
	 * 
	 * 使用方法
	 * 
	 * <pre>
	 * 		1：iBatis的配置文件中
	 * <br>
	 * 			&lt;select id=&quot;selectAllAccounts&quot; resultMap=&quot;AccountResult&quot;&gt;
	 * <br>
	 * 			select * from ACCOUNT
	 * <br>
	 * 		&lt;/select&gt;
	 * <br>
	 * 		2:分页调用方法
	 * <br>
	 * 注意从IntelliWeb传过来的OffSet的值是从0开始的
	 * <br>
	 * 		假设为第一页查询，且pagesize=5，则对应的参数offset=0，size=5；
	 * <br>
	 * String ibatis_query = &quot;Account.selectAllAccounts&quot;;
	 * <br>
	 * List list = defautMediator.find_iBatis(ibatis_query, null, 0, 2);
	 * <br>
	 * 		以此类推，如是第二页查询，则对应的参数offset=5,size=5
	 * <br>
	 * 		3：不需分页
	 * <br>
	 * List list = defautMediator.find_iBatis(ibatis_query, null, 0, -999999);
	 * <br>
	 * </pre>
	 * 
	 * @param queryID
	 *            在iBatis映射文件中定义的语句编号
	 * @param para
	 *            参数列表，可为null
	 * @param offset
	 *            查询结果的起始行，从0开始。如果不需要分页，则设offset置为0，同时size设置为-999999。
	 * @param size
	 *            查询结果的最大行数。如果不需要分页，则size设置为-999999，同时设offset置为0
	 * @return 返回值将是映射文件中的查询语句中定义的ResultMap或者ResultClass组成的List
	 * @throws MediatorException
	 */
	public List<?> find_iBatis(final String queryID, final Object para, final int offset, final int size)
			throws MediatorException;

	/**
	 * 使用iBatis完成查询操作， 不支持分页<br>
	 * 
	 * @see com.cib.cap.base.dao.mediator.IDefaultMediator#find_iBatis(java.lang.String,
	 *      java.lang.Object, int, int)
	 * 
	 * @param queryName
	 *            在iBatis映射文件中定义的语句编号
	 * @param para
	 *            参数列表，可为null
	 * @return 返回值将是映射文件中的查询语句中定义的ResultMap或者ResultClass组成的List
	 * @throws MediatorException
	 */
	public List<Object> find_iBatis(String queryName, Object para) throws MediatorException;

	/**
	 * 根据条件使用Hibernate的HQL语句完成复杂的查询操作，由Hibernate根据不同的数据库完成分页功能。<br>
	 * <p/> 具有功能：<br>
	 * 1）支持查询分页，该方法会利用数据库本身的分页技术实现。说明如下：<br>
	 * &nbsp;&nbsp;&nbsp;&nbsp;a)如果数据库(如MySQL,Oracle,SQL Server2005等)支持limit
	 * n,m，查询效率最高；<br>
	 * &nbsp;&nbsp;&nbsp;&nbsp;b)如果数据库(如informix,Sybase 12.5.3,SQL Server等)支持top
	 * n，由于仍旧属于逻辑分页，因此查询效率次之（查询结果越大，效率越低）； <br>
	 * &nbsp;&nbsp;&nbsp;&nbsp;c)如果以上两种均不支持，查询效率最低。<br>
	 * 2）支持查询总记录数<br>
	 * 3）支持order by，group by,having等 <br>
	 * <p/> 不支持功能：<br>
	 * 1）不支持select里的嵌套子查询。如不允许这种用法：select a,b,(select c from table1) as d from
	 * table2 ...<br>
	 * 2）条件与条件之间不支持or，而是用and。<br>
	 * 
	 * 建议：不推荐通过Hibernate来完成大量数据或者海量数据的查询，以及多表复杂关联后的查询
	 * 
	 * 使用方法<br>
	 * 1：调用方法：<br>
	 * 场景A:select后面的域可以是来自一个也可以是来自多个对象,如select vo1.a,vo1.b,vo2.c,vo2.d from
	 * vo1,vo2 where,则返回值是对象数值组成的列表，保存的是值<br>
	 * String hibernate_query="select objectId,accountNo,createdTime from
	 * AccountVO";<br>
	 * 
	 * 场景B:不管是多对象关联还是单对象，如select a from VO1,VO2....或者select a from
	 * VO1,则返回值是属性值组成的列表<br>
	 * String hibernate_query="select accountNo from AccountVO";<br>
	 * 
	 * 场景C,返回值都在一个对象中，该对象可以是一个hibernate中注册的vo，也可以是任意的一个java pojo<br>
	 * String hibernate_query="select new
	 * com.cib.app.account.vo.AccountVO(objectId,accountNo,createdTime) from
	 * AccountVO";<br>
	 * 
	 * 场景D,从两个不同对象中取值，from vo1,vo2,返回值是Object[],其中object[0]是vo1，object[1]是vo2<br>
	 * 还要注意的是，如下的from
	 * AccountVO,CompanyVO查询语句，由于没有对象之间的条件交互，得出的结果是笛卡尔乘积，即AccountVO的结果数乘上CompanyVO的结果数<br>
	 * String hibernate_query=" from AccountVO,CompanyVO";<br>
	 * 
	 * 场景E,直接使用from xx,如果是from AccountVO，则返回AccountVO的列表<br>
	 * String hibernate_query=" from AccountVO ";<br>
	 * 
	 * 场景F,含有in的操作,如下，返回的是AccountVO的列表<br>
	 * String hibernate_query=" from AccountVO accVO where accVO.objectId not in
	 * (select compVO.objectId from CompanyVO compVO) ";<br>
	 * 
	 * 2：解析结果<br>
	 * Object[] objs=defautMediator.find_Hibernate_ComposedHQL(hibernate_query,
	 * null, null, null, 1,18, true, null, null, null);<br>
	 * int count = ((Integer)objs[1]).intValue();<br>
	 * List list=(List)objs[0];<br>
	 * Iterator it=list.iterator();<br>
	 * 
	 * 场景A的解析<br>
	 * while(it.hasNext())<br> {<br>
	 * Object[] rs=(Object[])it.next();<br>
	 * System.out.println( rs[1] );<br> }<br>
	 * 
	 * 场景B的解析<br>
	 * while(it.hasNext())<br> {<br>
	 * String rs=(String)it.next();<br>
	 * System.out.println( rs );<br> }<br>
	 * 
	 * 场景C的解析<br>
	 * while(it.hasNext())<br> {<br>
	 * AccountVO rs=(AccountVO)it.next();<br>
	 * System.out.println( rs.getAccountNo() );<br> }<br>
	 * 
	 * 场景D的解析<br>
	 * while(it.hasNext())<br> {<br>
	 * Object[] rs=(Object[])it.next();<br>
	 * AccountVO vo1=(AccountVO)rs[0];<br>
	 * CompanyVO vo2=(CompanyVO)rs[1];<br>
	 * System.out.println("accountNo："+ vo1.getAccountNo() );<br>
	 * System.out.println("company name:："+ vo2.getName() );<br> }<br>
	 * 
	 * 场景E的解析<br>
	 * while(it.hasNext())<br> {<br>
	 * AccountVO rs=(AccountVO)it.next();<br>
	 * System.out.println( rs.getAccountNo() );<br> }<br>
	 * 
	 * 场景F的解析<br>
	 * while(it.hasNext())<br> {<br>
	 * AccountVO rs=(AccountVO)it.next();<br>
	 * System.out.println( rs.getAccountNo() );<br> } <br>
	 * 
	 * 
	 * @param hql
	 *            HQL查询语句（不带Where条件）。不允许在select段内使用子查询，如不允许这种用法：<br>
	 *            select a,b,(select c from table1) as d from table2 ...<br>
	 *            1)对于查询全部对象属性，(&lt;b&gt;select *&lt;/b&gt;)不可写。如：from TUser；<br>
	 *            2)对于查询部分对象属性，则必须写完整，如：select userName,password from TUser;<br>
	 * @param propertyNames
	 *            查询条件的属性名列表
	 * @param operators
	 *            查询条件的操作符列表，如果查询条件中存在不为&lt;b&gt;=&lt;/b&gt;的操作符，需要填写该列表，否则为null，<br>
	 *            应与属性名列表一一对应。操作符包括=, &gt;=, &lt;=, &lt;&gt;, !=, like。
	 * @param values
	 *            查询条件的值列表，该列表应当与属性列表一一对应
	 * @param offset
	 *            查询结果的起始行，从0开始。如果不需要，则设置为-1。
	 * @param size
	 *            查询结果的最大行数。如果不需要，则设置为-1
	 * @param isTotalSize
	 *            是否需要返回本次查询的总记录数，默认false
	 * @param orderBy
	 *            排序字符串,不含order by字符串，如orderBy=&quot;a desc,b
	 *            asc&quot;,最后生成为：order by a desc,b asc
	 * @param groupBy
	 *            分组字符串,不含group by 字符串，如groupBy=&quot;a desc,b
	 *            asc&quot;,最后生成为：group by a desc,b asc
	 * @param otherCause
	 *            where后面的其它语句，如排序(order by),分组(group by)及聚集(having)。
	 *            如&quot;group by name order by name desc&quot;
	 * @return Object[] 有两个值，第一个值表示查询结果列表List list = (List)Object[0]<br>
	 *         第二个表示查询返回的总记录数，int count = ((Integer)Object[1]).intValue;<br>
	 * @throws com.cib.cap.base.exception.MediatorException
	 *             &lt;/pre&gt;
	 * 
	 */
	public Object[] find_Hibernate_ComposedHQL(final String hql, final String[] propertyNames,
			final String[] operators, final Object[] values, final int offset, final int size,
			final boolean isTotalSize, final String orderBy, final String groupBy, final String otherCause)
			throws MediatorException;

	/**
	 * 通过Hibernate的命名查询方式，完成分页查询<br>
	 * 
	 * 使用方法<br>
	 * 
	 * <pre>
	 * 		1:Hibernate的配置文件中
	 * <br>
	 * 		&lt;sql-query name=&quot;com.cib.app.account.vo.AccountVO.queryAll&quot;&gt;
	 * <br>
	 * 		&lt;return alias=&quot;account&quot; class=&quot;com.cib.app.account.vo.AccountVO&quot; /&gt;
	 * <br>
	 * 			select accountky,accountNo,createdtime FROM account
	 * <br>
	 * 	&lt;/sql-query&gt;
	 * <br>
	 * 		2：调用方法
	 * <br>
	 * String hibernate_namedquery = &quot;com.cib.app.account.vo.AccountVO.queryAll&quot;;
	 * <br>
	 * Object[] objs = defautMediator.find_Hibernate_NamedQuery(hibernate_namedquery, null, 0, 5, true);
	 * <br>
	 * </pre>
	 * 
	 * @param queryID
	 *            Hibernate配置文件里的查询语句的编号
	 * @param params
	 *            参数
	 * @param offset
	 *            分页起始
	 * @param size
	 *            每页记录数
	 * @param isTotalSize
	 *            是否要取出查询的总数
	 * @return 有两个值，第一个值表示查询结果列表List list = (List)Object[0]<br>
	 *         第二个表示查询返回的总记录数，int count = ((Integer)Object[1]).intValue;
	 * @throws MediatorException
	 */
	public Object[] find_Hibernate_NamedQuery(final String queryID, final Object[] params, final int offset,
			final int size, final boolean isTotalSize) throws MediatorException;

	/**
	 * 获取Hibernate模板对象
	 * 
	 * @return HibernateTemplate Hibernate模板对象
	 */
	public HibernateTemplate getHibernateTemplate() throws MediatorException;

	/**
	 * 获取JdbcTemplate模板对象
	 * 
	 * @return JdbcTemplate jdbc模板对象
	 */
	public JdbcTemplate getJdbcTemplate() throws MediatorException;

	/**
	 * 获取iBatis模板对象
	 * 
	 * @return SqlMapClientTemplate iBatis模板对象
	 */
	public SqlMapClientTemplate getSqlMapClientTemplate() throws MediatorException;
}
